Termination of rewriting strategies: a generic approach

We propose a generic termination proof method for rewriting under strategies, based on an explicit induction on the termination property. Rewriting trees on ground terms are modeled by proof trees, generated by alternatively applying narrowing and abstracting steps. The induction principle is applied through the abstraction mechanism, where terms are replaced by variables representing any of their normal forms. The induction ordering is not given a priori, but defined with ordering constraints, incrementally set during the proof. Abstraction constraints can be used to control the narrowing mechanism, well known to easily diverge. The generic method is then instantiated for the innermost, outermost and local strategies.Comment: 49 page

ELIOS-OBJ theorem proving in a specification language

Projet EURECAIn the context of the executable specification language OBJ3 an order-sorted completion procedure is implemented, providing automatically convergent specifications from user-given ones. This feature is of first importance to ensure unambiguity and termination of the rewriting execution process. We describe here how we specified a modular completion design in terms of inference rules and control language, using OBJ3 itself. On another hand, the specific problems encountered to integrate a completion process in an already reduction-oriented environment are pointed out

Knuth-Bendix procedure and non deterministic behavior. An example

In this note, we present and study a typical example to illustrate the non determinism of the Knuth-Bendix algorithm with respect to the ordering it uses. Our example shows how different orderings on terms lead to different completion processes, and how eleven different completion sessions produce only two different rewrite systems

Termination of Order-sorted Rewriting

International audienceIn this paper, the problem of termination of rewriting in order-sorted algebras is addressed for the first time. Our goal is to perform termination proofs of programs for executable specification languages like OBJ3. An extension of Lexicographic Path Ordering is proposed, that gives a termination proof for order-sorted rewrite systems, that would not terminate in the unsorted case. We mention also, that this extension provides a termination tool for unsorted terminating systems, that usual orderings cannot handle

Induction for Positive Almost Sure Termination - Extended version -

In this paper, we propose an inductive approach to prove positive almost sure termination of probabilistic rewriting under the innermost strategy. We extend to the probabilistic case a technique we proposed for termination of usual rewriting under strategies. The induction principle consists in assuming that terms smaller than the starting terms for an induction ordering are positively almost surely terminating. The proof is developed in generating proof trees, modelizing rewriting trees, in alternatively applying abstraction steps, expressing the application of the induction hypothesis, and narrowing steps, simulating the possible rewriting steps after abstraction. This technique is fully automatable for rewrite systems on constants, very useful to modelize probabilistic protocols

Termination of Priority Rewriting - Extended version

Introducing priorities in rewriting increases the expressive power of rules and helps to limit computations. Priority rewriting is used in rule-based programming as well as in functional programming. Termination of priority rewriting is then important to guarantee that programs give a result. We describe an inductive proof method for termination of priority rewriting, relying on an explicit induction on the termination property and working by generating proof trees, which model the rewriting relation by using abstraction and narrowing

Investigations on termination of equational rewriting

This paper is a report of detailed investigations on the termination problem of rewriting modulo equational theories. We present here three approachs of this problem. We point out the difficulties and explain how the methods fail, giving some ideas issued from a rigorous observation of the failing processes. The first part is a new approach of the classical associative commutative (AC in short) orderings using the cooperation on abstract relations. We point out this proof method is not easy, because of an infinity of critical pairs to be considered. The second work consists in adapting the AC orderings with flattening to ensure termination modulo a large class of permutative theories. But the characterization of this class points out nothing other than the theories included in AC, for which the AC termination methods can be used. So we deduce, AC is the maximal class working with flattening. In the third chapter of this report, we propose a new AC ordering, replacing both flatening and distributing transformations by a single powerful transformation. We exhibit a counter-example to show that this method does not provide an F-compatible ordering

Termination of rewriting under strategies: a generic approach

We propose a synthesis of three induction based algorithms, we already have given to prove termination of rewrite rule based programs, respectively for the innermost, the outermost and the local strategies. A generic inference principle is presented, based on an explicit induction on the termination property, which genetates ordering constraints, defining the induction relation. The generic inference principle is then instantiated to provide proof procedures for the three specific considered strategies

Termination Proofs Using gpo Ordering Constraints : Extended Version

We present here an algorithm for proving termination of term rewriting systems by \gpo ordering constraint solving. The algorithm gives, as automatically as possible, an appropriate instance of the gpo generic ordering proving termination of a given system. Constraint solving is done efficiently thanks to a DAG shared term data structure

Computing Constructor Forms with Non Terminating Rewrite Programs - Extended version -

In the context of the study of rule-based programming, we focus in this paper on the property of C-reducibility, expressing that every term reduces to a constructor term on at least one of its rewriting derivations. This property implies completeness of function definitions, and enables to stop evaluations of a program on a constructor form, even if the program is not terminating. We propose an inductive procedure proving C-reducibility of rewriting. The rewriting relation on ground terms is simulated through an abstraction mechanism and narrowing. The induction hypothesis allows assuming that terms smaller than the starting terms rewrite into a constructor term. The existence of the induction ordering is checked during the proof process, by ensuring satisfiability of ordering constraints. The proof is constructive, in the sense that the branch leading to a constructor term can be computed from the proof trees establishing C-reducibility for every term